(function() {

    var undefined;
  
    var VERSION = '4.17.5';
  
    var FUNC_ERROR_TEXT = 'Expected a function';
  
    var NAN = 0 / 0;
  
    var nullTag = '[object Null]',
      symbolTag = '[object Symbol]',
      undefinedTag = '[object Undefined]';
  
    var reTrim = /^\s+|\s+$/g;
  
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
  
    var reIsBinary = /^0b[01]+$/i;
  
    var reIsOctal = /^0o[0-7]+$/i;
  
    var freeParseInt = parseInt;
  
    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
    var root = freeGlobal || freeSelf || Function('return this')();
  
    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  
    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  
    var objectProto = Object.prototype;
  
    var hasOwnProperty = objectProto.hasOwnProperty;
  
    var nativeObjectToString = objectProto.toString;
  
    var Symbol = root.Symbol,
      symToStringTag = Symbol ? Symbol.toStringTag : undefined;
  
    var nativeMax = Math.max,
      nativeMin = Math.min;
  
    var realNames = {};
  
    function lodash() {
    }
  
    function baseGetTag(value) {
      if (value == null) {
        return value === undefined ? undefinedTag : nullTag;
      }
      return (symToStringTag && symToStringTag in Object(value)) ?
        getRawTag(value) :
        objectToString(value);
    }
  
    function getRawTag(value) {
      var isOwn = hasOwnProperty.call(value, symToStringTag),
       tag = value[symToStringTag];
  
      try {
        value[symToStringTag] = undefined;
        var unmasked = true;
      } catch (e) {}
  
      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }
  
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }
  
    var now = function() {
      return Date.now();
    };
  
    function debounce(func, wait, options) {
      var lastArgs,
        lastThis,
        maxWait,
        result,
        timerId,
        lastCallTime,
        lastInvokeTime = 0,
        leading = false,
        maxing = false,
        trailing = true;
  
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      wait = toNumber(wait) || 0;
      if (isObject(options)) {
        leading = !!options.leading;
        maxing = 'maxWait' in options;
        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
        trailing = 'trailing' in options ? !!options.trailing : trailing;
      }
  
      function invokeFunc(time) {
        var args = lastArgs,
          thisArg = lastThis;
  
        lastArgs = lastThis = undefined;
        lastInvokeTime = time;
        result = func.apply(thisArg, args);
        return result;
      }
  
      function leadingEdge(time) {
        lastInvokeTime = time;
        timerId = setTimeout(timerExpired, wait);
        return leading ? invokeFunc(time) : result;
      }
  
      function remainingWait(time) {
        var timeSinceLastCall = time - lastCallTime,
          timeSinceLastInvoke = time - lastInvokeTime,
          timeWaiting = wait - timeSinceLastCall;
  
        return maxing ?
          nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) :
          timeWaiting;
      }
  
      function shouldInvoke(time) {
        var timeSinceLastCall = time - lastCallTime,
          timeSinceLastInvoke = time - lastInvokeTime;
        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
      }
  
      function timerExpired() {
        var time = now();
        if (shouldInvoke(time)) {
          return trailingEdge(time);
        }
        // Restart the timer.
        timerId = setTimeout(timerExpired, remainingWait(time));
      }
  
      function trailingEdge(time) {
        timerId = undefined;
  
        // Only invoke if we have `lastArgs` which means `func` has been
        // debounced at least once.
        if (trailing && lastArgs) {
          return invokeFunc(time);
        }
        lastArgs = lastThis = undefined;
        return result;
      }
  
      function cancel() {
        if (timerId !== undefined) {
          clearTimeout(timerId);
        }
        lastInvokeTime = 0;
        lastArgs = lastCallTime = lastThis = timerId = undefined;
      }
  
      function flush() {
        return timerId === undefined ? result : trailingEdge(now());
      }
  
      function debounced() {
        var time = now(),
          isInvoking = shouldInvoke(time);
  
        lastArgs = arguments;
        lastThis = this;
        lastCallTime = time;
  
        if (isInvoking) {
          if (timerId === undefined) {
            return leadingEdge(lastCallTime);
          }
          if (maxing) {
            // Handle invocations in a tight loop.
            timerId = setTimeout(timerExpired, wait);
            return invokeFunc(lastCallTime);
          }
        }
        if (timerId === undefined) {
          timerId = setTimeout(timerExpired, wait);
        }
        return result;
      }
      debounced.cancel = cancel;
      debounced.flush = flush;
      return debounced;
    }
  
    function throttle(func, wait, options) {
      var leading = true,
        trailing = true;
  
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      if (isObject(options)) {
        leading = 'leading' in options ? !!options.leading : leading;
        trailing = 'trailing' in options ? !!options.trailing : trailing;
      }
      return debounce(func, wait, {
        'leading': leading,
        'maxWait': wait,
        'trailing': trailing
      });
    }
  
  
    function isObject(value) {
      var type = typeof value;
      return value != null && (type == 'object' || type == 'function');
    }
  
    function isObjectLike(value) {
      return value != null && typeof value == 'object';
    }
  
    function isSymbol(value) {
      return typeof value == 'symbol' ||
        (isObjectLike(value) && baseGetTag(value) == symbolTag);
    }
  
    function toNumber(value) {
      if (typeof value == 'number') {
        return value;
      }
      if (isSymbol(value)) {
        return NAN;
      }
      if (isObject(value)) {
        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
        value = isObject(other) ? (other + '') : other;
      }
      if (typeof value != 'string') {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, '');
      var isBinary = reIsBinary.test(value);
      return (isBinary || reIsOctal.test(value)) ?
        freeParseInt(value.slice(2), isBinary ? 2 : 8) :
        (reIsBadHex.test(value) ? NAN : +value);
    }
  
    lodash.debounce = debounce;
    lodash.throttle = throttle;
  
    lodash.isObject = isObject;
    lodash.isObjectLike = isObjectLike;
    lodash.isSymbol = isSymbol;
    lodash.now = now;
    lodash.toNumber = toNumber;
  
    lodash.VERSION = VERSION;
  
    /*--------------------------------------------------------------------------*/
  
    // Some AMD build optimizers, like r.js, check for condition patterns like:
    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
      root._ = lodash;
      define(function() {
        return lodash;
      });
    }
    // Check for `exports` after `define` in case a build optimizer adds it.
    else if (freeModule) {
      // Export for Node.js.
      (freeModule.exports = lodash)._ = lodash;
      // Export for CommonJS support.
      freeExports._ = lodash;
    } else {
      // Export to the global object.
      root._ = lodash;
    }
  }.call(this));